using System;
using System.Collections.Generic;

/// <summary>
/// 管理Message，负责Message的派发，派发到每一个界面上去
/// 类似UIManager，是单利
/// </summary>
public class MessageCenter : Singleton_UI<MessageCenter>
{
    /// <summary>
    /// 定义一个消息事件的字典的集合
    /// </summary>
    private Dictionary<string, List<MessageEvent>> dicMessageEvents = null;

    /// <summary>
    /// 复写初始化呢函数
    /// 初始化消息事件的字典的集合
    /// </summary>
    public override void Init()
    {
        dicMessageEvents = new Dictionary<string, List<MessageEvent>>();
    }


    #region 添加和移除消息监听
    /// <summary>
    /// 添加监听的方法
    /// </summary>
    /// <param name="messageType">消息的类型</param>
    /// <param name="messageEvent">要监听的事件</param>
    public void AddListener(MessageType_UI messageType, MessageEvent messageEvent)
    {
        AddListener(messageType.ToString(), messageEvent);
    }

    /// <summary>
    /// 移除监听的方法
    /// </summary>
    /// <param name="messageType">消息的类型</param>
    /// <param name="messageEvent">要监听的事件</param>
    public void RemoveListener(MessageType_UI messageType, MessageEvent messageEvent)
    {
        RemoveListener(messageType.ToString(), messageEvent);
    }

    /// <summary>
    /// 添加监听的方法
    /// </summary>
    /// <param name="messageName">对应的Key</param>
    /// <param name="messageEvent">要监听的事件，函数</param>
    public void AddListener(string messageName, MessageEvent messageEvent)
    {
        //一个“消息机制的全局委托”的集合
        List<MessageEvent> list = null;

        //Dictionary<string, List<MessageEvent>> dicMessageEvents = null;
        //如果 定义的消息事件的字典集合 里包含参数键
        if (dicMessageEvents.ContainsKey(messageName))
        {
            //给上面的集合赋对应值
            list = dicMessageEvents[messageName];
        }
        else
        {
            //new 一个对象
            list = new List<MessageEvent>();
            //添加到 主字典里
            dicMessageEvents.Add(messageName, list);
        }
        //“消息机制的全局委托”的集合里 添加 参数委托类型变量
        if (!list.Contains(messageEvent))
        {
            list.Add(messageEvent);
        }
    }

    /// <summary>
    /// 移除监听的方法
    /// </summary>
    /// <param name="messageName">对应的Key</param>
    /// <param name="messageEvent">要监听的事件，函数</param>
    public void RemoveListener(string messageName, MessageEvent messageEvent)
    {
        //如果 定义的消息事件的字典集合 里包含参数键，存在这个key才能移除它
        if (dicMessageEvents.ContainsKey(messageName))
        {
            //定义一个“消息机制的全局委托”的集合，用该键值赋值
            List<MessageEvent> list = dicMessageEvents[messageName];

            //移除操作
            if (list.Contains(messageEvent))//List<T>.Contains 方法 (T):确定某元素是否在 List<T> 中。
            {
                list.Remove(messageEvent);//移除它
            }
            if (list.Count <= 0)
            {
                dicMessageEvents.Remove(messageName);//从主集合中移除
            }
        }
    }

    /// <summary>
    /// 移除所有监听的事件
    /// </summary>
    public void RemoveAllListener()
    {
        dicMessageEvents.Clear();
    }
    #endregion


    #region 发送消息 Send Message
    /// <summary>
    /// 发送消息(重载函数)
    /// </summary>
    /// <param name="name">消息名.</param>
    /// <param name="sender">发送者.</param>
    public void SendMessage(string name, object sender)
    {
        //调用 发送消息的主体函数，参数为构造触动消息类
        SendMessage(new Message(name, sender));
    }

    /// <summary>
    /// 发送消息(重载函数)
    /// </summary>
    /// <param name="name">消息名.</param>
    /// <param name="sender">发送者.</param>
    /// <param name="content">发送的内容.</param>
    public void SendMessage(string name, object sender, object content)
    {
        //调用 发送消息的主体函数，参数为构造触动消息类
        SendMessage(new Message(name, sender, content));
    }

    /// <summary>
    /// 发送消息(重载函数)
    /// </summary>
    /// <param name="name">消息名.</param>
    /// <param name="sender">发送者.</param>
    /// <param name="content">发送的内容.</param>
    /// <param name="_dicParams">可变参数.</param>
    public void SendMessage(string name, object sender, object content, params object[] dicParams)
    {
        //调用 发送消息的主体函数，参数为构造触动消息类
        SendMessage(new Message(name, sender, content, dicParams));
    }

    /// <summary>
    /// 发送消息(重载函数)
    /// </summary>
    /// <param name="message">消息体类 Message</param>
    public void SendMessage(Message message)
    {
        DoMessageDispatcher(message);
    }


    /// <summary>
    /// 发送消息的主体实际功能函数
    /// </summary>
    /// <param name="message">消息类</param>
    private void DoMessageDispatcher(Message message)
    {
        //如果"消息事件的字典的集合"为空，或者不包含参数键值，返回。
        if (dicMessageEvents == null || !dicMessageEvents.ContainsKey(message.Name))
            return;
        ////定义一个“消息机制的全局委托”的集合，用该键值赋值
        List<MessageEvent> list = dicMessageEvents[message.Name];

        //取得所有监听的事件，实现它
        for (int i = 0; i < list.Count; i++)
        {
            MessageEvent messageEvent = list[i];
            if (null != messageEvent)
            {
                messageEvent(message);//实现监听的事件
            }
        }
    }
    #endregion

}


